package com.ruoyi.receipt.utils;


import com.ruoyi.common.core.redis.RedisCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
public class FormulaUtil {
    @Autowired
    private RedisCache redisCache;

    private String timeconstant; //时间分的幂系数
    private String timepower;//时间分的幂指数
    private String timeadd;//时间分加数
    private String exponent;//难题正确率幂指数
    private String coefficient;//难题正确率前面系数
    private String isconsant;//难题正确率后面的系数
    private String innovatecoefficient;//创新分幂系数
    private String innovatepower;//创新分幂指数
    private String innovateadd;//创新分后面的系数
    private String concentrationtotal;//专注分总分
    private String frequencyscore;//切出每次扣得分值
    private String maxfconsant;//切出次数扣分最大值
    private String freqscore;//切出每分钟扣得分值
    private String maxfreq;//切出分值最大分值
    private String minconcentration;//专注分值最低分值
    private String coefficient1;//时间和专注分相乘系数
    private String maxcoefficient;//综合分最大值得系数
    private String secondcoefficient;//综合分第二系数
    private String mincoefficient;//mincoefficient

    /**
     * 时间分  最低分为60 最高90
     * power 时长
     * exponent 幂指数
     * coefficient 前面系数
     * consant 后面的系数
     * @return
     */

    public int time(int power){
        double y=0;
        //获取幂系数
        timeconstant=  redisCache.getCacheObject("sys_config:timeconstant");
        timepower=redisCache.getCacheObject("sys_config:timepower");
        timeadd=redisCache.getCacheObject("sys_config:timeadd");

        y=Double.parseDouble(timeconstant)*Math.pow(power, Double.parseDouble(timepower))+Double.parseDouble(timeadd);
        if (y<=60){
            y=60;
        }
        if (y>90){
            y=90;
        }
        return (int) y;
    }
    /**
     * 能力分   最低分为0 最高100
     * power 正确率
     * capacitypower 正确率幂指数
     * capacitycoefficient 正确率前面系数
     * capacityadd 正确率后面的系数
     */
    public int capacity(int power){
        double y=0;
        coefficient=redisCache.getCacheObject("sys_config:capacitycoefficient");
        exponent=redisCache.getCacheObject("sys_config:capacitypower");
        isconsant=redisCache.getCacheObject("sys_config:capacityadd");
        y=Double.parseDouble(coefficient)*Math.pow(power, Double.parseDouble(exponent))+Double.parseDouble(isconsant);
        if (y<=0){
            y=0;
        }
        if (y>100){
            y=100;
        }
        return (int) y;
    }
    /**
     * 创新分  最低分为0 最高105
     * power 难题正确率
     * innovatepower 难题正确率幂指数
     * innovatecoefficient 难题正确率前面系数
     * innovateadd 难题正确率后面的系数
     */
    public int innovate(int power){
        double y=0;
        innovatecoefficient=redisCache.getCacheObject("sys_config:innovatecoefficient");
        innovatepower=redisCache.getCacheObject("sys_config:innovatepower");
        innovateadd=redisCache.getCacheObject("sys_config:innovateadd");
        y=Double.parseDouble(innovatecoefficient)*Math.pow(power,Double.parseDouble(innovatepower))+Double.parseDouble(innovateadd);
        if (y<=0){
            y=0;
        }
        if (y>105){
            y=105;
        }
        return (int) y;
    }
    /**
     * 专注分
     *  points 专注分的初始值
     *  frequency 切出次数
     *  fconsant切出次数常量
     *  Maxfconsant 切除次数的最大值
     *  freq切出分钟
     *  Freqconsant切出分钟常量
     *  Maxfreq切出分钟最大值
     */
    public  int fengrossment(int frequency,int freq){
        double z=0;
        concentrationtotal=redisCache.getCacheObject("sys_config:concentrationtotal");
        frequencyscore=redisCache.getCacheObject("sys_config:frequency");
        maxfconsant=redisCache.getCacheObject("sys_config:maxfconsant");
        freqscore=redisCache.getCacheObject("sys_config:freq");
        maxfreq=redisCache.getCacheObject("sys_config:maxfreq");
        minconcentration=redisCache.getCacheObject("sys_config:minconcentration");


        double a=Double.parseDouble(frequencyscore)*frequency;
        double b=freq*Double.parseDouble(freqscore);
        if (a<=Double.parseDouble(maxfconsant) &&b<=Double.parseDouble(maxfreq)){
            z=Double.parseDouble(concentrationtotal)-a-b;
        }if (a>=Double.parseDouble(maxfconsant) &&b>=Double.parseDouble(maxfreq)){
            z=Double.parseDouble(concentrationtotal)-Double.parseDouble(maxfconsant)-Double.parseDouble(maxfreq);
        }if (a<=Double.parseDouble(maxfconsant) &&b>=Double.parseDouble(maxfreq)){
            z=Double.parseDouble(concentrationtotal)-a-Double.parseDouble(maxfreq);
        }if (a>=Double.parseDouble(maxfconsant) &&b<=Double.parseDouble(maxfreq)){
            z=Double.parseDouble(concentrationtotal)-Double.parseDouble(maxfconsant  )-b;
        }
        if (z<=Integer.parseInt(minconcentration)){
            z=Integer.parseInt(minconcentration);
        }
        if (z<80){
            z=80;
        }
        if (z>100){
            z=100;
        }
        return (int)z;
    }
    /**
    * 综合分计算
    * time  学习时间
    * capacity 正确率
    * innovate 难题正确率
    * frequency 切出次数
    * freq切出分钟
     * 上面是需要传的  下面是获取的
    * coefficient 时间分和专注分系数
    * maxcoefficient 最大值系数
    * secondcoefficient 综合分第二系数
    * mincoefficient 最小值对应系数
    */
public  int synthesize(int time,int capacity,int innovate,int frequency,int freq){
    double a=0;
    coefficient1=redisCache.getCacheObject("sys_config:coefficient");
    maxcoefficient=redisCache.getCacheObject("sys_config:maxcoefficient");
    secondcoefficient=redisCache.getCacheObject("sys_config:secondcoefficient");
    mincoefficient=redisCache.getCacheObject("sys_config:mincoefficient");
    //获取时间分
    int time1 = time(time);
    //获取专注分
    int fengrossment = fengrossment(frequency, freq);
    //计算时间分和专注分相乘的结果
    double z=time1*fengrossment*Double.parseDouble(coefficient1);
    //获取能力分
    int capacity1 = capacity(capacity);
    //获取创新分
    int innovate1 = innovate(innovate);
   int[] arr={(int) z,capacity1,innovate1};
    Arrays.sort(arr);
    a=arr[0]*Double.parseDouble(mincoefficient)+arr[1]*Double.parseDouble(secondcoefficient)+arr[2]*Double.parseDouble(maxcoefficient);
    if (a>100){
        a=100;
    }
    if (a<0){
        a=0;
    }
    return  (int) a;
}

}

